home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / lisp / wgdb-42.lha / wgdb-4.2 / gdb / eval.c < prev    next >
C/C++ Source or Header  |  1992-09-11  |  31KB  |  1,055 lines
  1. /* Evaluate expressions for GDB.
  2.    Copyright (C) 1986, 1987, 1989, 1991 Free Software Foundation, Inc.
  3.  
  4. This file is part of GDB.
  5.  
  6. This program is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 2 of the License, or
  9. (at your option) any later version.
  10.  
  11. This program is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with this program; if not, write to the Free Software
  18. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20. #include <stdio.h>
  21. #include "defs.h"
  22. #include "param.h"
  23. #include "symtab.h"
  24. #include "value.h"
  25. #include "expression.h"
  26. #include "target.h"
  27. #include "frame.h"
  28.  
  29. #define    NULL_TYPE    ((struct type *)0)
  30.  
  31.  
  32. /* Parse the string EXP as a C expression, evaluate it,
  33.    and return the result as a number.  */
  34.  
  35. CORE_ADDR
  36. parse_and_eval_address (exp)
  37.      char *exp;
  38. {
  39.   struct expression *expr = parse_expression (exp);
  40.   register CORE_ADDR addr;
  41.   register struct cleanup *old_chain
  42.     = make_cleanup (free_current_contents, &expr);
  43.  
  44.   addr = value_as_pointer (evaluate_expression (expr));
  45.   do_cleanups (old_chain);
  46.   return addr;
  47. }
  48.  
  49. /* Like parse_and_eval_address but takes a pointer to a char * variable
  50.    and advanced that variable across the characters parsed.  */
  51.  
  52. CORE_ADDR
  53. parse_and_eval_address_1 (expptr)
  54.      char **expptr;
  55. {
  56.   struct expression *expr = parse_exp_1 (expptr, (struct block *)0, 0);
  57.   register CORE_ADDR addr;
  58.   register struct cleanup *old_chain
  59.     = make_cleanup (free_current_contents, &expr);
  60.  
  61.   addr = value_as_pointer (evaluate_expression (expr));
  62.   do_cleanups (old_chain);
  63.   return addr;
  64. }
  65.  
  66. value
  67. parse_and_eval (exp)
  68.      char *exp;
  69. {
  70.   struct expression *expr = parse_expression (exp);
  71.   register value val;
  72.   register struct cleanup *old_chain
  73.     = make_cleanup (free_current_contents, &expr);
  74.  
  75.   val = evaluate_expression (expr);
  76.   do_cleanups (old_chain);
  77.   return val;
  78. }
  79.  
  80. /* Parse up to a comma (or to a closeparen)
  81.    in the string EXPP as an expression, evaluate it, and return the value.
  82.    EXPP is advanced to point to the comma.  */
  83.  
  84. value
  85. parse_to_comma_and_eval (expp)
  86.      char **expp;
  87. {
  88.   struct expression *expr = parse_exp_1 (expp, (struct block *) 0, 1);
  89.   register value val;
  90.   register struct cleanup *old_chain
  91.     = make_cleanup (free_current_contents, &expr);
  92.  
  93.   val = evaluate_expression (expr);
  94.   do_cleanups (old_chain);
  95.   return val;
  96. }
  97.  
  98. /* Evaluate an expression in internal prefix form
  99.    such as is constructed by parse.y.
  100.  
  101.    See expression.h for info on the format of an expression.  */
  102.  
  103. static value evaluate_subexp ();
  104. static value evaluate_subexp_for_address ();
  105. static value evaluate_subexp_for_sizeof ();
  106. static value evaluate_subexp_with_coercion ();
  107.  
  108. /* Values of NOSIDE argument to eval_subexp.  */
  109. enum noside
  110. { EVAL_NORMAL,
  111.   EVAL_SKIP,            /* Only effect is to increment pos.  */
  112.   EVAL_AVOID_SIDE_EFFECTS,    /* Don't modify any variables or
  113.                    call any functions.  The value
  114.                    returned will have the correct
  115.                    type, and will have an
  116.                    approximately correct lvalue
  117.                    type (inaccuracy: anything that is
  118.                    listed as being in a register in
  119.                    the function in which it was
  120.                    declared will be lval_register).  */
  121. };
  122.  
  123. value
  124. evaluate_expression (exp)
  125.      struct expression *exp;
  126. {
  127.   int pc = 0;
  128.   return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_NORMAL);
  129. }
  130.  
  131. /* Evaluate an expression, avoiding all memory references
  132.    and getting a value whose type alone is correct.  */
  133.  
  134. value
  135. evaluate_type (exp)
  136.      struct expression *exp;
  137. {
  138.   int pc = 0;
  139.   return evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_AVOID_SIDE_EFFECTS);
  140. }
  141.  
  142. static value
  143. evaluate_subexp (expect_type, exp, pos, noside)
  144.      struct type *expect_type;
  145.      register struct expression *exp;
  146.      register int *pos;
  147.      enum noside noside;
  148. {
  149.   enum exp_opcode op;
  150.   int tem;
  151.   register int pc, pc2, oldpos;
  152.   register value arg1, arg2, arg3;
  153.   int nargs;
  154.   value *argvec;
  155.  
  156.   pc = (*pos)++;
  157.   op = exp->elts[pc].opcode;
  158.  
  159.   switch (op)
  160.     {
  161.     case OP_SCOPE:
  162.       tem = strlen (&exp->elts[pc + 2].string);
  163.       (*pos) += 3 + ((tem + sizeof (union exp_element))
  164.              / sizeof (union exp_element));
  165.       arg1 = value_static_field (exp->elts[pc + 1].type,
  166.                  &exp->elts[pc + 2].string, -1);
  167.       if (arg1 == NULL)
  168.     error ("There is no field named %s", &exp->elts[pc + 2].string);
  169.       return arg1;
  170.  
  171.     case OP_LONG:
  172.       (*pos) += 3;
  173.       return value_from_longest (exp->elts[pc + 1].type,
  174.                   exp->elts[pc + 2].longconst);
  175.  
  176.     case OP_DOUBLE:
  177.       (*pos) += 3;
  178.       return value_from_double (exp->elts[pc + 1].type,
  179.                 exp->elts[pc + 2].doubleconst);
  180.  
  181.     case OP_VAR_VALUE:
  182.       (*pos) += 2;
  183.       if (noside == EVAL_SKIP)
  184.     goto nosideret;
  185.       if (noside == EVAL_AVOID_SIDE_EFFECTS)
  186.     {
  187.       struct symbol * sym = exp->elts[pc + 1].symbol;
  188.       enum lval_type lv;
  189.  
  190.       switch (SYMBOL_CLASS (sym))
  191.         {
  192.         case LOC_CONST:
  193.         case LOC_LABEL:
  194.         case LOC_CONST_BYTES:
  195.           lv = not_lval;
  196.           break;
  197.  
  198.         case LOC_REGISTER:
  199.         case LOC_REGPARM:
  200.           lv = lval_register;
  201.           break;
  202.  
  203.         default:
  204.           lv = lval_memory;
  205.           break;
  206.         }
  207.  
  208.       return value_zero (SYMBOL_TYPE (sym), lv);
  209.     }
  210.       else
  211.     return value_of_variable (exp->elts[pc + 1].symbol);
  212.  
  213.     case OP_LAST:
  214.       (*pos) += 2;
  215.       return
  216.     access_value_history (longest_to_int (exp->elts[pc + 1].longconst));
  217.  
  218.     case OP_REGISTER:
  219.       (*pos) += 2;
  220.       return value_of_register (longest_to_int (exp->elts[pc + 1].longconst));
  221.  
  222.     case OP_INTERNALVAR:
  223.       (*pos) += 2;
  224.       return value_of_internalvar (exp->elts[pc + 1].internalvar);
  225.  
  226.     case OP_STRING:
  227.       tem = strlen (&exp->elts[pc + 1].string);
  228.       (*pos) += 2 + ((tem + sizeof (union exp_element))
  229.              / sizeof (union exp_element));
  230.       if (noside == EVAL_SKIP)
  231.     goto nosideret;
  232.       return value_string (&exp->elts[pc + 1].string, tem);
  233.  
  234.     case TERNOP_COND:
  235.       /* Skip third and second args to evaluate the first one.  */
  236.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  237.       if (value_zerop (arg1))
  238.     {
  239.       evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
  240.       return evaluate_subexp (NULL_TYPE, exp, pos, noside);
  241.     }
  242.       else
  243.     {
  244.       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  245.       evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
  246.       return arg2;
  247.     }
  248.  
  249.     case OP_FUNCALL:
  250.       (*pos) += 2;
  251.       op = exp->elts[*pos].opcode;
  252.       if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
  253.     {
  254.       int fnptr;
  255.  
  256.       nargs = longest_to_int (exp->elts[pc + 1].longconst) + 1;
  257.       /* First, evaluate the structure into arg2 */
  258.       pc2 = (*pos)++;
  259.  
  260.       if (noside == EVAL_SKIP)
  261.         goto nosideret;
  262.  
  263.       if (op == STRUCTOP_MEMBER)
  264.         {
  265.           arg2 = evaluate_subexp_for_address (exp, pos, noside);
  266.         }
  267.       else
  268.         {
  269.           arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  270.         }
  271.  
  272.       /* If the function is a virtual function, then the
  273.          aggregate value (providing the structure) plays
  274.          its part by providing the vtable.  Otherwise,
  275.          it is just along for the ride: call the function
  276.          directly.  */
  277.  
  278.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  279.  
  280.       fnptr = longest_to_int (value_as_long (arg1));
  281.       /* FIXME-tiemann: this is way obsolete.  */
  282.       if (fnptr < 128)
  283.         {
  284.           struct type *basetype;
  285.           int i, j;
  286.           basetype = TYPE_TARGET_TYPE (VALUE_TYPE (arg2));
  287.           basetype = TYPE_VPTR_BASETYPE (basetype);
  288.           for (i = TYPE_NFN_FIELDS (basetype) - 1; i >= 0; i--)
  289.         {
  290.           struct fn_field *f = TYPE_FN_FIELDLIST1 (basetype, i);
  291.           /* If one is virtual, then all are virtual.  */
  292.           if (TYPE_FN_FIELD_VIRTUAL_P (f, 0))
  293.             for (j = TYPE_FN_FIELDLIST_LENGTH (basetype, i) - 1; j >= 0; --j)
  294.               if (TYPE_FN_FIELD_VOFFSET (f, j) == fnptr)
  295.             {
  296.               value vtbl;
  297.               value base = value_ind (arg2);
  298.               struct type *fntype = lookup_pointer_type (TYPE_FN_FIELD_TYPE (f, j));
  299.  
  300.               if (TYPE_VPTR_FIELDNO (basetype) < 0)
  301.                 fill_in_vptr_fieldno (basetype);
  302.  
  303.               VALUE_TYPE (base) = basetype;
  304.               vtbl = value_field (base, TYPE_VPTR_FIELDNO (basetype));
  305.               VALUE_TYPE (vtbl) = lookup_pointer_type (fntype);
  306.               VALUE_TYPE (arg1) = builtin_type_int;
  307.               arg1 = value_subscript (vtbl, arg1);
  308.               VALUE_TYPE (arg1) = fntype;
  309.               goto got_it;
  310.             }
  311.         }
  312.           if (i < 0)
  313.         error ("virtual function at index %d not found", fnptr);
  314.         }
  315.       else
  316.         {
  317.           VALUE_TYPE (arg1) = lookup_pointer_type (TYPE_TARGET_TYPE (VALUE_TYPE (arg1)));
  318.         }
  319.     got_it:
  320.  
  321.       /* Now, say which argument to start evaluating from */
  322.       tem = 2;
  323.     }
  324.       else if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR)
  325.     {
  326.       /* Hair for method invocations */
  327.       int tem2;
  328.  
  329.       nargs = longest_to_int (exp->elts[pc + 1].longconst) + 1;
  330.       /* First, evaluate the structure into arg2 */
  331.       pc2 = (*pos)++;
  332.       tem2 = strlen (&exp->elts[pc2 + 1].string);
  333.       *pos += 2 + (tem2 + sizeof (union exp_element)) / sizeof (union exp_element);
  334.       if (noside == EVAL_SKIP)
  335.         goto nosideret;
  336.  
  337.       if (op == STRUCTOP_STRUCT)
  338.         {
  339.           arg2 = evaluate_subexp_for_address (exp, pos, noside);
  340.         }
  341.       else
  342.         {
  343.           arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  344.         }
  345.       /* Now, say which argument to start evaluating from */
  346.       tem = 2;
  347.     }
  348.       else
  349.     {
  350.       nargs = longest_to_int (exp->elts[pc + 1].longconst);
  351.       tem = 0;
  352.     }
  353.       argvec = (value *) alloca (sizeof (value) * (nargs + 2));
  354.       for (; tem <= nargs; tem++)
  355.     /* Ensure that array expressions are coerced into pointer objects. */
  356.     argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
  357.  
  358.       /* signal end of arglist */
  359.       argvec[tem] = 0;
  360.  
  361.       if (op == STRUCTOP_STRUCT || op == STRUCTOP_PTR)
  362.     {
  363.       int static_memfuncp;
  364.       value temp = arg2;
  365.  
  366.       argvec[1] = arg2;
  367.       argvec[0] =
  368.         value_struct_elt (&temp, argvec+1, &exp->elts[pc2 + 1].string,
  369.                   &static_memfuncp,
  370.                   op == STRUCTOP_STRUCT
  371.                   ? "structure" : "structure pointer");
  372.       if (VALUE_OFFSET (temp))
  373.         {
  374.           arg2 = value_from_longest (lookup_pointer_type (VALUE_TYPE (temp)),
  375.                       value_as_long (arg2)+VALUE_OFFSET (temp));
  376.           argvec[1] = arg2;
  377.         }
  378.       if (static_memfuncp)
  379.         {
  380.           argvec[1] = argvec[0];
  381.           nargs--;
  382.           argvec++;
  383.         }
  384.     }
  385.       else if (op == STRUCTOP_MEMBER || op == STRUCTOP_MPTR)
  386.     {
  387.       argvec[1] = arg2;
  388.       argvec[0] = arg1;
  389.     }
  390.  
  391.       if (noside == EVAL_SKIP)
  392.     goto nosideret;
  393.       if (noside == EVAL_AVOID_SIDE_EFFECTS)
  394.     {
  395.       /* If the return type doesn't look like a function type, call an
  396.          error.  This can happen if somebody tries to turn a variable into
  397.          a function call. This is here because people often want to
  398.          call, eg, strcmp, which gdb doesn't know is a function.  If
  399.          gdb isn't asked for it's opinion (ie. through "whatis"),
  400.          it won't offer it. */
  401.  
  402.       struct type *ftype =
  403.         TYPE_TARGET_TYPE (VALUE_TYPE (argvec[0]));
  404.  
  405.       if (ftype)
  406.         return allocate_value (TYPE_TARGET_TYPE (VALUE_TYPE (argvec[0])));
  407.       else
  408.         error ("Expression of type other than \"Function returning ...\" used as function");
  409.     }
  410.       return target_call_function (argvec[0], nargs, argvec + 1);
  411.  
  412.     case STRUCTOP_STRUCT:
  413.       tem = strlen (&exp->elts[pc + 1].string);
  414.       (*pos) += 2 + ((tem + sizeof (union exp_element))
  415.              / sizeof (union exp_element));
  416.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  417.       if (noside == EVAL_SKIP)
  418.     goto nosideret;
  419.       if (noside == EVAL_AVOID_SIDE_EFFECTS)
  420.     return value_zero (lookup_struct_elt_type (VALUE_TYPE (arg1),
  421.                            &exp->elts[pc + 1].string,
  422.                            1),
  423.                lval_memory);
  424.       else
  425.     {
  426.       value temp = arg1;
  427.       return value_struct_elt (&temp, (value *)0, &exp->elts[pc + 1].string,
  428.                    (int *) 0, "structure");
  429.     }
  430.  
  431.     case STRUCTOP_PTR:
  432.       tem = strlen (&exp->elts[pc + 1].string);
  433.       (*pos) += 2 + (tem + sizeof (union exp_element)) / sizeof (union exp_element);
  434.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  435.       if (noside == EVAL_SKIP)
  436.     goto nosideret;
  437.       if (noside == EVAL_AVOID_SIDE_EFFECTS)
  438.     return value_zero (lookup_struct_elt_type (TYPE_TARGET_TYPE
  439.                            (VALUE_TYPE (arg1)),
  440.                            &exp->elts[pc + 1].string,
  441.                            1),
  442.                lval_memory);
  443.       else
  444.     {
  445.       value temp = arg1;
  446.       return value_struct_elt (&temp, (value *)0, &exp->elts[pc + 1].string,
  447.                    (int *) 0, "structure pointer");
  448.     }
  449.  
  450.     case STRUCTOP_MEMBER:
  451.       arg1 = evaluate_subexp_for_address (exp, pos, noside);
  452.       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  453.       if (noside == EVAL_SKIP)
  454.     goto nosideret;
  455.       /* Now, convert these values to an address.  */
  456.       if (TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_PTR
  457.       || ((TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg2)))
  458.            != TYPE_CODE_MEMBER)
  459.           && (TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg2)))
  460.           != TYPE_CODE_METHOD)))
  461.     error ("non-pointer-to-member value used in pointer-to-member construct");
  462.       arg3 = value_from_longest (
  463.     lookup_pointer_type (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (VALUE_TYPE (arg2)))),
  464.                   value_as_long (arg1) + value_as_long (arg2));
  465.       return value_ind (arg3);
  466.  
  467.     case STRUCTOP_MPTR:
  468.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  469.       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  470.       if (noside == EVAL_SKIP)
  471.     goto nosideret;
  472.       /* Now, convert these values to an address.  */
  473.       if (TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_PTR
  474.       || (TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg2))) != TYPE_CODE_MEMBER
  475.           && TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg2))) != TYPE_CODE_METHOD))
  476.     error ("non-pointer-to-member value used in pointer-to-member construct");
  477.       arg3 = value_from_longest (
  478.     lookup_pointer_type (TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (VALUE_TYPE (arg2)))),
  479.                   value_as_long (arg1) + value_as_long (arg2));
  480.       return value_ind (arg3);
  481.  
  482.     case BINOP_ASSIGN:
  483.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  484.       arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
  485.       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
  486.     return arg1;
  487.       if (binop_user_defined_p (op, arg1, arg2))
  488.     return value_x_binop (arg1, arg2, op, OP_NULL);
  489.       else
  490.     return value_assign (arg1, arg2);
  491.  
  492.     case BINOP_ASSIGN_MODIFY:
  493.       (*pos) += 2;
  494.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  495.       arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
  496.       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
  497.     return arg1;
  498.       op = exp->elts[pc + 1].opcode;
  499.       if (binop_user_defined_p (op, arg1, arg2))
  500.     return value_x_binop (arg1, arg2, BINOP_ASSIGN_MODIFY, op);
  501.       else if (op == BINOP_ADD)
  502.     arg2 = value_add (arg1, arg2);
  503.       else if (op == BINOP_SUB)
  504.     arg2 = value_sub (arg1, arg2);
  505.       else
  506.     arg2 = value_binop (arg1, arg2, op);
  507.       return value_assign (arg1, arg2);
  508.  
  509.     case BINOP_ADD:
  510.       arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
  511.       arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
  512.       if (noside == EVAL_SKIP)
  513.     goto nosideret;
  514.       if (binop_user_defined_p (op, arg1, arg2))
  515.     return value_x_binop (arg1, arg2, op, OP_NULL);
  516.       else
  517.     return value_add (arg1, arg2);
  518.  
  519.     case BINOP_SUB:
  520.       arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
  521.       arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
  522.       if (noside == EVAL_SKIP)
  523.     goto nosideret;
  524.       if (binop_user_defined_p (op, arg1, arg2))
  525.     return value_x_binop (arg1, arg2, op, OP_NULL);
  526.       else
  527.     return value_sub (arg1, arg2);
  528.  
  529.     case BINOP_MUL:
  530.     case BINOP_DIV:
  531.     case BINOP_REM:
  532.     case BINOP_LSH:
  533.     case BINOP_RSH:
  534.     case BINOP_LOGAND:
  535.     case BINOP_LOGIOR:
  536.     case BINOP_LOGXOR:
  537.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  538.       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  539.       if (noside == EVAL_SKIP)
  540.     goto nosideret;
  541.       if (binop_user_defined_p (op, arg1, arg2))
  542.     return value_x_binop (arg1, arg2, op, OP_NULL);
  543.       else
  544.     if (noside == EVAL_AVOID_SIDE_EFFECTS
  545.         && op == BINOP_DIV)
  546.       return value_zero (VALUE_TYPE (arg1), not_lval);
  547.       else
  548.     return value_binop (arg1, arg2, op);
  549.  
  550.     case BINOP_SUBSCRIPT:
  551.       arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
  552.       arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
  553.       if (noside == EVAL_SKIP)
  554.     goto nosideret;
  555.       if (noside == EVAL_AVOID_SIDE_EFFECTS)
  556.     return value_zero (TYPE_TARGET_TYPE (VALUE_TYPE (arg1)),
  557.                VALUE_LVAL (arg1));
  558.                
  559.       if (binop_user_defined_p (op, arg1, arg2))
  560.     return value_x_binop (arg1, arg2, op, OP_NULL);
  561.       else
  562.     return value_subscript (arg1, arg2);
  563.       
  564.     case BINOP_AND:
  565.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  566.       if (noside == EVAL_SKIP)
  567.     {
  568.       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  569.       goto nosideret;
  570.     }
  571.       
  572.       oldpos = *pos;
  573.       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
  574.       *pos = oldpos;
  575.       
  576.       if (binop_user_defined_p (op, arg1, arg2)) 
  577.     {
  578.       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  579.       return value_x_binop (arg1, arg2, op, OP_NULL);
  580.     }
  581.       else
  582.     {
  583.       tem = value_zerop (arg1);
  584.       arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
  585.                   (tem ? EVAL_SKIP : noside));
  586.       return value_from_longest (builtin_type_int,
  587.                   (LONGEST) (!tem && !value_zerop (arg2)));
  588.     }
  589.  
  590.     case BINOP_OR:
  591.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  592.       if (noside == EVAL_SKIP)
  593.     {
  594.       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  595.       goto nosideret;
  596.     }
  597.       
  598.       oldpos = *pos;
  599.       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
  600.       *pos = oldpos;
  601.       
  602.       if (binop_user_defined_p (op, arg1, arg2)) 
  603.     {
  604.       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  605.       return value_x_binop (arg1, arg2, op, OP_NULL);
  606.     }
  607.       else
  608.     {
  609.       tem = value_zerop (arg1);
  610.       arg2 = evaluate_subexp (NULL_TYPE, exp, pos,
  611.                   (!tem ? EVAL_SKIP : noside));
  612.       return value_from_longest (builtin_type_int,
  613.                   (LONGEST) (!tem || !value_zerop (arg2)));
  614.     }
  615.  
  616.     case BINOP_EQUAL:
  617.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  618.       arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
  619.       if (noside == EVAL_SKIP)
  620.     goto nosideret;
  621.       if (binop_user_defined_p (op, arg1, arg2))
  622.     {
  623.       return value_x_binop (arg1, arg2, op, OP_NULL);
  624.     }
  625.       else
  626.     {
  627.       tem = value_equal (arg1, arg2);
  628.       return value_from_longest (builtin_type_int, (LONGEST) tem);
  629.     }
  630.  
  631.     case BINOP_NOTEQUAL:
  632.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  633.       arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
  634.       if (noside == EVAL_SKIP)
  635.     goto nosideret;
  636.       if (binop_user_defined_p (op, arg1, arg2))
  637.     {
  638.       return value_x_binop (arg1, arg2, op, OP_NULL);
  639.     }
  640.       else
  641.     {
  642.       tem = value_equal (arg1, arg2);
  643.       return value_from_longest (builtin_type_int, (LONGEST) ! tem);
  644.     }
  645.  
  646.     case BINOP_LESS:
  647.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  648.       arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
  649.       if (noside == EVAL_SKIP)
  650.     goto nosideret;
  651.       if (binop_user_defined_p (op, arg1, arg2))
  652.     {
  653.       return value_x_binop (arg1, arg2, op, OP_NULL);
  654.     }
  655.       else
  656.     {
  657.       tem = value_less (arg1, arg2);
  658.       return value_from_longest (builtin_type_int, (LONGEST) tem);
  659.     }
  660.  
  661.     case BINOP_GTR:
  662.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  663.       arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
  664.       if (noside == EVAL_SKIP)
  665.     goto nosideret;
  666.       if (binop_user_defined_p (op, arg1, arg2))
  667.     {
  668.       return value_x_binop (arg1, arg2, op, OP_NULL);
  669.     }
  670.       else
  671.     {
  672.       tem = value_less (arg2, arg1);
  673.       return value_from_longest (builtin_type_int, (LONGEST) tem);
  674.     }
  675.  
  676.     case BINOP_GEQ:
  677.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  678.       arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
  679.       if (noside == EVAL_SKIP)
  680.     goto nosideret;
  681.       if (binop_user_defined_p (op, arg1, arg2))
  682.     {
  683.       return value_x_binop (arg1, arg2, op, OP_NULL);
  684.     }
  685.       else
  686.     {
  687.       tem = value_less (arg1, arg2);
  688.       return value_from_longest (builtin_type_int, (LONGEST) ! tem);
  689.     }
  690.  
  691.     case BINOP_LEQ:
  692.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  693.       arg2 = evaluate_subexp (VALUE_TYPE (arg1), exp, pos, noside);
  694.       if (noside == EVAL_SKIP)
  695.     goto nosideret;
  696.       if (binop_user_defined_p (op, arg1, arg2))
  697.     {
  698.       return value_x_binop (arg1, arg2, op, OP_NULL);
  699.     }
  700.       else 
  701.     {
  702.       tem = value_less (arg2, arg1);
  703.       return value_from_longest (builtin_type_int, (LONGEST) ! tem);
  704.     }
  705.  
  706.     case BINOP_REPEAT:
  707.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  708.       arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  709.       if (noside == EVAL_SKIP)
  710.     goto nosideret;
  711.       if (TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_INT)
  712.     error ("Non-integral right operand for \"@\" operator.");
  713.       if (noside == EVAL_AVOID_SIDE_EFFECTS)
  714.     return allocate_repeat_value (VALUE_TYPE (arg1),
  715.                       longest_to_int (value_as_long (arg2)));
  716.       else
  717.     return value_repeat (arg1, longest_to_int (value_as_long (arg2)));
  718.  
  719.     case BINOP_COMMA:
  720.       evaluate_subexp (NULL_TYPE, exp, pos, noside);
  721.       return evaluate_subexp (NULL_TYPE, exp, pos, noside);
  722.  
  723.     case UNOP_NEG:
  724.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  725.       if (noside == EVAL_SKIP)
  726.     goto nosideret;
  727.       if (unop_user_defined_p (op, arg1))
  728.     return value_x_unop (arg1, op);
  729.       else
  730.     return value_neg (arg1);
  731.  
  732.     case UNOP_LOGNOT:
  733.       /* C++: check for and handle destructor names.  */
  734.       op = exp->elts[*pos].opcode;
  735.  
  736.       /* FIXME-tiemann: this is a cop-out.  */
  737.       if (op == OP_SCOPE)
  738.     error ("destructor in eval");
  739.  
  740.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  741.       if (noside == EVAL_SKIP)
  742.     goto nosideret;
  743.       if (unop_user_defined_p (UNOP_LOGNOT, arg1))
  744.     return value_x_unop (arg1, UNOP_LOGNOT);
  745.       else
  746.     return value_lognot (arg1);
  747.  
  748.     case UNOP_ZEROP:
  749.       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  750.       if (noside == EVAL_SKIP)
  751.     goto nosideret;
  752.       if (unop_user_defined_p (op, arg1))
  753.     return value_x_unop (arg1, op);
  754.       else
  755.     return value_from_longest (builtin_type_int,
  756.                 (LONGEST) value_zerop (arg1));
  757.  
  758.     case UNOP_IND:
  759.       if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_PTR)
  760.         expect_type = TYPE_TARGET_TYPE (expect_type);
  761.       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
  762.       if (noside == EVAL_SKIP)
  763.     goto nosideret;
  764.       if (noside == EVAL_AVOID_SIDE_EFFECTS)
  765.     {
  766.       if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR
  767.           || TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_REF
  768.           /* In C you can dereference an array to get the 1st elt.  */
  769.           || TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_ARRAY
  770.           )
  771.         return value_zero (TYPE_TARGET_TYPE (VALUE_TYPE (arg1)),
  772.                    lval_memory);
  773.       else if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_INT)
  774.         /* GDB allows dereferencing an int.  */
  775.         return value_zero (builtin_type_int, lval_memory);
  776.       else
  777.         error ("Attempt to take contents of a non-pointer value.");
  778.     }
  779.       return value_ind (arg1);
  780.  
  781.     case UNOP_ADDR:
  782.       /* C++: check for and handle pointer to members.  */
  783.       
  784.       op = exp->elts[*pos].opcode;
  785.  
  786.       if (noside == EVAL_SKIP)
  787.     {
  788.       if (op == OP_SCOPE)
  789.         {
  790.           char *name = &exp->elts[pc+3].string;
  791.           int temm = strlen (name);
  792.           (*pos) += 2 + (temm + sizeof (union exp_element)) / sizeof (union exp_element);
  793.         }
  794.       else
  795.         evaluate_subexp (expect_type, exp, pos, EVAL_SKIP);
  796.       goto nosideret;
  797.     }
  798.  
  799.       if (op == OP_SCOPE)
  800.     {
  801.       char *name = &exp->elts[pc+3].string;
  802.       int temm = strlen (name);
  803.       struct type *domain = exp->elts[pc+2].type;
  804.       (*pos) += 2 + (temm + sizeof (union exp_element)) / sizeof (union exp_element);
  805.       arg1 = value_struct_elt_for_address (domain, expect_type, name);
  806.       if (arg1)
  807.         return arg1;
  808.       error ("no field `%s' in structure", name);
  809.     }
  810.       else
  811.     return evaluate_subexp_for_address (exp, pos, noside);
  812.  
  813.     case UNOP_SIZEOF:
  814.       if (noside == EVAL_SKIP)
  815.     {
  816.       evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
  817.       goto nosideret;
  818.     }
  819.       return evaluate_subexp_for_sizeof (exp, pos);
  820.  
  821.     case UNOP_CAST:
  822.       (*pos) += 2;
  823.       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
  824.       if (noside == EVAL_SKIP)
  825.     goto nosideret;
  826.       return value_cast (exp->elts[pc + 1].type, arg1);
  827.  
  828.     case UNOP_MEMVAL:
  829.       (*pos) += 2;
  830.       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
  831.       if (noside == EVAL_SKIP)
  832.     goto nosideret;
  833.       if (noside == EVAL_AVOID_SIDE_EFFECTS)
  834.     return value_zero (exp->elts[pc + 1].type, lval_memory);
  835.       else
  836.     return value_at_lazy (exp->elts[pc + 1].type,
  837.                   value_as_pointer (arg1));
  838.  
  839.     case UNOP_PREINCREMENT:
  840.       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
  841.       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
  842.     return arg1;
  843.       else if (unop_user_defined_p (op, arg1))
  844.     {
  845.       return value_x_unop (arg1, op);
  846.     }
  847.       else
  848.     {
  849.       arg2 = value_add (arg1, value_from_longest (builtin_type_char, 
  850.                            (LONGEST) 1));
  851.       return value_assign (arg1, arg2);
  852.     }
  853.  
  854.     case UNOP_PREDECREMENT:
  855.       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
  856.       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
  857.     return arg1;
  858.       else if (unop_user_defined_p (op, arg1))
  859.     {
  860.       return value_x_unop (arg1, op);
  861.     }
  862.       else
  863.     {
  864.       arg2 = value_sub (arg1, value_from_longest (builtin_type_char, 
  865.                            (LONGEST) 1));
  866.       return value_assign (arg1, arg2);
  867.     }
  868.  
  869.     case UNOP_POSTINCREMENT:
  870.       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
  871.       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
  872.     return arg1;
  873.       else if (unop_user_defined_p (op, arg1))
  874.     {
  875.       return value_x_unop (arg1, op);
  876.     }
  877.       else
  878.     {
  879.       arg2 = value_add (arg1, value_from_longest (builtin_type_char, 
  880.                            (LONGEST) 1));
  881.       value_assign (arg1, arg2);
  882.       return arg1;
  883.     }
  884.  
  885.     case UNOP_POSTDECREMENT:
  886.       arg1 = evaluate_subexp (expect_type, exp, pos, noside);
  887.       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
  888.     return arg1;
  889.       else if (unop_user_defined_p (op, arg1))
  890.     {
  891.       return value_x_unop (arg1, op);
  892.     }
  893.       else
  894.     {
  895.       arg2 = value_sub (arg1, value_from_longest (builtin_type_char, 
  896.                            (LONGEST) 1));
  897.       value_assign (arg1, arg2);
  898.       return arg1;
  899.     }
  900.     
  901.     case OP_THIS:
  902.       (*pos) += 1;
  903.       return value_of_this (1);
  904.  
  905.     default:
  906.       error ("internal error: I do not know how to evaluate what you gave me");
  907.     }
  908.  
  909.  nosideret:
  910.   return value_from_longest (builtin_type_long, (LONGEST) 1);
  911. }
  912.  
  913. /* Evaluate a subexpression of EXP, at index *POS,
  914.    and return the address of that subexpression.
  915.    Advance *POS over the subexpression.
  916.    If the subexpression isn't an lvalue, get an error.
  917.    NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
  918.    then only the type of the result need be correct.  */
  919.  
  920. static value
  921. evaluate_subexp_for_address (exp, pos, noside)
  922.      register struct expression *exp;
  923.      register int *pos;
  924.      enum noside noside;
  925. {
  926.   enum exp_opcode op;
  927.   register int pc;
  928.  
  929.   pc = (*pos);
  930.   op = exp->elts[pc].opcode;
  931.  
  932.   switch (op)
  933.     {
  934.     case UNOP_IND:
  935.       (*pos)++;
  936.       return evaluate_subexp (NULL_TYPE, exp, pos, noside);
  937.  
  938.     case UNOP_MEMVAL:
  939.       (*pos) += 3;
  940.       return value_cast (lookup_pointer_type (exp->elts[pc + 1].type),
  941.              evaluate_subexp (NULL_TYPE, exp, pos, noside));
  942.  
  943.     case OP_VAR_VALUE:
  944.       (*pos) += 3;
  945.       if (noside == EVAL_AVOID_SIDE_EFFECTS)
  946.     {
  947.       struct type *type =
  948.         lookup_pointer_type (SYMBOL_TYPE (exp->elts[pc + 1].symbol));
  949.       enum address_class sym_class =
  950.         SYMBOL_CLASS (exp->elts[pc + 1].symbol);
  951.  
  952.       if (sym_class == LOC_CONST
  953.           || sym_class == LOC_CONST_BYTES
  954.           || sym_class == LOC_REGISTER
  955.           || sym_class == LOC_REGPARM)
  956.         error ("Attempt to take address of register or constant.");
  957.  
  958.     return
  959.       value_zero (type, not_lval);
  960.     }
  961.       else
  962.     return locate_var_value (exp->elts[pc + 1].symbol, (FRAME) 0);
  963.  
  964.     default:
  965.       if (noside == EVAL_AVOID_SIDE_EFFECTS)
  966.     {
  967.       value x = evaluate_subexp (NULL_TYPE, exp, pos, noside);
  968.       if (VALUE_LVAL (x) == lval_memory)
  969.         return value_zero (lookup_pointer_type (VALUE_TYPE (x)),
  970.                    not_lval);
  971.       else
  972.         error ("Attempt to take address of non-lval");
  973.     }
  974.       return value_addr (evaluate_subexp (NULL_TYPE, exp, pos, noside));
  975.     }
  976. }
  977.  
  978. /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
  979.    When used in contexts where arrays will be coerced anyway,
  980.    this is equivalent to `evaluate_subexp'
  981.    but much faster because it avoids actually fetching array contents.  */
  982.  
  983. static value
  984. evaluate_subexp_with_coercion (exp, pos, noside)
  985.      register struct expression *exp;
  986.      register int *pos;
  987.      enum noside noside;
  988. {
  989.   register enum exp_opcode op;
  990.   register int pc;
  991.   register value val;
  992.  
  993.   pc = (*pos);
  994.   op = exp->elts[pc].opcode;
  995.  
  996.   switch (op)
  997.     {
  998.     case OP_VAR_VALUE:
  999.       if (TYPE_CODE (SYMBOL_TYPE (exp->elts[pc + 1].symbol)) == TYPE_CODE_ARRAY)
  1000.     {
  1001.       (*pos) += 3;
  1002.       val = locate_var_value (exp->elts[pc + 1].symbol, (FRAME) 0);
  1003.       return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (SYMBOL_TYPE (exp->elts[pc + 1].symbol))),
  1004.                  val);
  1005.     }
  1006.       default:
  1007.     return evaluate_subexp (NULL_TYPE, exp, pos, noside);
  1008.     }
  1009. }
  1010.  
  1011. /* Evaluate a subexpression of EXP, at index *POS,
  1012.    and return a value for the size of that subexpression.
  1013.    Advance *POS over the subexpression.  */
  1014.  
  1015. static value
  1016. evaluate_subexp_for_sizeof (exp, pos)
  1017.      register struct expression *exp;
  1018.      register int *pos;
  1019. {
  1020.   enum exp_opcode op;
  1021.   register int pc;
  1022.   value val;
  1023.  
  1024.   pc = (*pos);
  1025.   op = exp->elts[pc].opcode;
  1026.  
  1027.   switch (op)
  1028.     {
  1029.       /* This case is handled specially
  1030.      so that we avoid creating a value for the result type.
  1031.      If the result type is very big, it's desirable not to
  1032.      create a value unnecessarily.  */
  1033.     case UNOP_IND:
  1034.       (*pos)++;
  1035.       val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
  1036.       return value_from_longest (builtin_type_int, (LONGEST)
  1037.               TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (val))));
  1038.  
  1039.     case UNOP_MEMVAL:
  1040.       (*pos) += 3;
  1041.       return value_from_longest (builtin_type_int, 
  1042.                   (LONGEST) TYPE_LENGTH (exp->elts[pc + 1].type));
  1043.  
  1044.     case OP_VAR_VALUE:
  1045.       (*pos) += 3;
  1046.       return value_from_longest (builtin_type_int,
  1047.      (LONGEST) TYPE_LENGTH (SYMBOL_TYPE (exp->elts[pc + 1].symbol)));
  1048.  
  1049.     default:
  1050.       val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
  1051.       return value_from_longest (builtin_type_int,
  1052.                   (LONGEST) TYPE_LENGTH (VALUE_TYPE (val)));
  1053.     }
  1054. }
  1055.